#include"depythonize_c_lex"
QUEX_NAMESPACE_MAIN_OPEN
/* Global */QUEX_NAME(Mode)  QUEX_NAME(ML_COMMENT_READER);
/* Global */QUEX_NAME(Mode)  QUEX_NAME(END_OF_FILE);
/* Global */QUEX_NAME(Mode)  QUEX_NAME(STRING_READER);
/* Global */QUEX_NAME(Mode)  QUEX_NAME(PROGRAM);
/* Global */QUEX_NAME(Mode)  QUEX_NAME(ML_PREPROCESOR_READER);
#define self  (*(QUEX_TYPE_DERIVED_ANALYZER*)me)

    void
    QUEX_NAME(ML_COMMENT_READER_on_entry)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* FromMode) {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->ML_COMMENT_READER.has_entry_from(FromMode));
#endif

#line 258 "depythonize_c.qx"

    self.accumulator.clear();
  

#line 22 "depythonize_c_lex.cpp"
    }

    void
    QUEX_NAME(ML_COMMENT_READER_on_exit)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* ToMode)  {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->ML_COMMENT_READER.has_exit_to(ToMode));
#endif

#line 262 "depythonize_c.qx"

    self.accumulator.flush(QUEX_TKN_COMMENT);
  

#line 36 "depythonize_c_lex.cpp"

    }

#ifdef __QUEX_OPTION_INDENTATION_TRIGGER_SUPPORT        
    void
    QUEX_NAME(ML_COMMENT_READER_on_indentation)(QUEX_TYPE_ANALYZER* me, const int Indentation) {
__quex_assert(Indentation >= 0);
    }
#endif

#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
    bool
    QUEX_NAME(ML_COMMENT_READER_has_base)(const QUEX_NAME(Mode)* Mode) {

    switch( Mode->id ) {
    case QUEX_NAME(ModeID_END_OF_FILE): return true;
    case QUEX_NAME(ModeID_ML_COMMENT_READER): return true;
    default:
    ;
    }
    #ifdef __QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    std::cerr << "mode 'ML_COMMENT_READER' is not one of:\n";    std::cerr << "         END_OF_FILE\n";
        std::cerr << "         ML_COMMENT_READER\n";
    #endif // QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    return false;
    
    }
    bool
    QUEX_NAME(ML_COMMENT_READER_has_entry_from)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
    bool
    QUEX_NAME(ML_COMMENT_READER_has_exit_to)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
#endif    

    void
    QUEX_NAME(END_OF_FILE_on_entry)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* FromMode) {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->END_OF_FILE.has_entry_from(FromMode));
#endif

    }

    void
    QUEX_NAME(END_OF_FILE_on_exit)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* ToMode)  {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->END_OF_FILE.has_exit_to(ToMode));
#endif

    }

#ifdef __QUEX_OPTION_INDENTATION_TRIGGER_SUPPORT        
    void
    QUEX_NAME(END_OF_FILE_on_indentation)(QUEX_TYPE_ANALYZER* me, const int Indentation) {
__quex_assert(Indentation >= 0);
    }
#endif

#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
    bool
    QUEX_NAME(END_OF_FILE_has_base)(const QUEX_NAME(Mode)* Mode) {
    return false;
    }
    bool
    QUEX_NAME(END_OF_FILE_has_entry_from)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
    bool
    QUEX_NAME(END_OF_FILE_has_exit_to)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
#endif    

    void
    QUEX_NAME(STRING_READER_on_entry)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* FromMode) {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->STRING_READER.has_entry_from(FromMode));
#endif

#line 215 "depythonize_c.qx"

    self.accumulator.clear();
  

#line 123 "depythonize_c_lex.cpp"
    }

    void
    QUEX_NAME(STRING_READER_on_exit)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* ToMode)  {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->STRING_READER.has_exit_to(ToMode));
#endif

#line 219 "depythonize_c.qx"

    self.accumulator.flush(QUEX_TKN_STRING);
  

#line 137 "depythonize_c_lex.cpp"

    }

#ifdef __QUEX_OPTION_INDENTATION_TRIGGER_SUPPORT        
    void
    QUEX_NAME(STRING_READER_on_indentation)(QUEX_TYPE_ANALYZER* me, const int Indentation) {
__quex_assert(Indentation >= 0);
    }
#endif

#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
    bool
    QUEX_NAME(STRING_READER_has_base)(const QUEX_NAME(Mode)* Mode) {

    switch( Mode->id ) {
    case QUEX_NAME(ModeID_END_OF_FILE): return true;
    case QUEX_NAME(ModeID_STRING_READER): return true;
    default:
    ;
    }
    #ifdef __QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    std::cerr << "mode 'STRING_READER' is not one of:\n";    std::cerr << "         END_OF_FILE\n";
        std::cerr << "         STRING_READER\n";
    #endif // QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    return false;
    
    }
    bool
    QUEX_NAME(STRING_READER_has_entry_from)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
    bool
    QUEX_NAME(STRING_READER_has_exit_to)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
#endif    

    void
    QUEX_NAME(PROGRAM_on_entry)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* FromMode) {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->PROGRAM.has_entry_from(FromMode));
#endif

#line 104 "depythonize_c.qx"

    self.in_preprocessor_block = false;
  

#line 186 "depythonize_c_lex.cpp"
    }

    void
    QUEX_NAME(PROGRAM_on_exit)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* ToMode)  {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->PROGRAM.has_exit_to(ToMode));
#endif

    }

#ifdef __QUEX_OPTION_INDENTATION_TRIGGER_SUPPORT        
    void
    QUEX_NAME(PROGRAM_on_indentation)(QUEX_TYPE_ANALYZER* me, const int Indentation) {
__quex_assert(Indentation >= 0);
#line 108 "depythonize_c.qx"

    if(self.parentheses_counter == 0) //avoid indentation events between parentheses
    {
      if( Indentation > self.indentation_stack.back() ) {
        if( self.allow_opening_indentation_f ) {
          self.send(QUEX_TKN_BLOCK_OPEN);
          self.indentation_stack.push_back(Indentation);
        }
        else {
          // -- higher indentation where it was not allowed to indent higher
          //  => misaligned indentation //OJO! Necesario?
          self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
        }
      }
      else
      {
        while( self.indentation_stack.back() > Indentation ) {
          self.send(QUEX_TKN_BLOCK_CLOSE);
          self.indentation_stack.pop_back();
        }
    
        // -- 'landing' indentation has to fit an indentation border
        //  if not send an error
        if( self.indentation_stack.back() != Indentation )
          self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
      }
    }
    else
      self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
    self.allow_opening_indentation_f = true;
    return;
  

#line 235 "depythonize_c_lex.cpp"

    }
#endif

#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
    bool
    QUEX_NAME(PROGRAM_has_base)(const QUEX_NAME(Mode)* Mode) {

    switch( Mode->id ) {
    case QUEX_NAME(ModeID_END_OF_FILE): return true;
    case QUEX_NAME(ModeID_PROGRAM): return true;
    default:
    ;
    }
    #ifdef __QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    std::cerr << "mode 'PROGRAM' is not one of:\n";    std::cerr << "         END_OF_FILE\n";
        std::cerr << "         PROGRAM\n";
    #endif // QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    return false;
    
    }
    bool
    QUEX_NAME(PROGRAM_has_entry_from)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
    bool
    QUEX_NAME(PROGRAM_has_exit_to)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
#endif    

    void
    QUEX_NAME(ML_PREPROCESOR_READER_on_entry)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* FromMode) {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->ML_PREPROCESOR_READER.has_entry_from(FromMode));
#endif

#line 294 "depythonize_c.qx"

    self.in_preprocessor_block = true;
  

#line 278 "depythonize_c_lex.cpp"
    }

    void
    QUEX_NAME(ML_PREPROCESOR_READER_on_exit)(QUEX_TYPE_ANALYZER* me, const QUEX_NAME(Mode)* ToMode)  {
#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
__quex_assert(me->ML_PREPROCESOR_READER.has_exit_to(ToMode));
#endif

    }

#ifdef __QUEX_OPTION_INDENTATION_TRIGGER_SUPPORT        
    void
    QUEX_NAME(ML_PREPROCESOR_READER_on_indentation)(QUEX_TYPE_ANALYZER* me, const int Indentation) {
__quex_assert(Indentation >= 0);
#line 298 "depythonize_c.qx"

    if(self.parentheses_counter == 0)
    {
      if( Indentation > self.indentation_stack.back() ) {
        if( self.allow_opening_indentation_f ) {
          self.send(QUEX_TKN_BLOCK_OPEN);
          self.indentation_stack.push_back(Indentation);
        }
        else {
          // -- higher indentation where it was not allowed to indent higher
          //  => misaligned indentation
          self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
        }
      }
      else
      {
        while( self.indentation_stack.back() > Indentation ) {
          self.send(QUEX_TKN_BLOCK_CLOSE);
          self.indentation_stack.pop_back();
        }
    
        // -- 'landing' indentation has to fit an indentation border
        //  if not send an error
        if( self.indentation_stack.back() != Indentation )
          self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
      }
    }
    else
      self.send(QUEX_TKN_ERROR_MISALIGNED_INDENTATION, self.line_number_at_end());
    self.allow_opening_indentation_f = true;
    return;
  

#line 327 "depythonize_c_lex.cpp"

    }
#endif

#ifdef __QUEX_OPTION_RUNTIME_MODE_TRANSITION_CHECK
    bool
    QUEX_NAME(ML_PREPROCESOR_READER_has_base)(const QUEX_NAME(Mode)* Mode) {

    switch( Mode->id ) {
    case QUEX_NAME(ModeID_END_OF_FILE): return true;
    case QUEX_NAME(ModeID_ML_PREPROCESOR_READER): return true;
    default:
    ;
    }
    #ifdef __QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    std::cerr << "mode 'ML_PREPROCESOR_READER' is not one of:\n";    std::cerr << "         END_OF_FILE\n";
        std::cerr << "         ML_PREPROCESOR_READER\n";
    #endif // QUEX_OPTION_ERROR_OUTPUT_ON_MODE_CHANGE_ERROR
    return false;
    
    }
    bool
    QUEX_NAME(ML_PREPROCESOR_READER_has_entry_from)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
    bool
    QUEX_NAME(ML_PREPROCESOR_READER_has_exit_to)(const QUEX_NAME(Mode)* Mode) {
    return true; // default
    }
#endif    
#undef self
QUEX_NAMESPACE_MAIN_CLOSE


    /* 
     * MODE: ML_COMMENT_READER
     * 
     *     BASE MODE SEQUENCE:
     *       END_OF_FILE
     * 
     *     PATTERN-ACTION PAIRS:
     *       (195) ML_COMMENT_READER: {P_ML_COMMENT_DELIMITER_END}
     * 
     * 
     * MODE: STRING_READER
     * 
     *     BASE MODE SEQUENCE:
     *       END_OF_FILE
     * 
     *     PATTERN-ACTION PAIRS:
     *       (186) STRING_READER: {P_BACKSLASHED_STRING_DELIMITER}
     *       (188) STRING_READER: {P_BACKSLASHED_BACKSLASH}
     *       (190) STRING_READER: {P_STRING_DELIMITER}
     *       (193) STRING_READER: .
     * 
     * 
     * MODE: PROGRAM
     * 
     *     BASE MODE SEQUENCE:
     *       END_OF_FILE
     * 
     *     PATTERN-ACTION PAIRS:
     *       (164) PROGRAM:     {P_BACKSLASH}
     *       (166) PROGRAM:     {P_SEMICOLON}
     *       (168) PROGRAM:     {P_ML_COMMENT_DELIMITER_START}
     *       (170) PROGRAM:     {P_STRING_DELIMITER}
     *       (172) PROGRAM:     {P_ONE_LINE_COMMENT}
     *       (175) PROGRAM:     {P_PREPROCESSOR_MULTILINE_START}
     *       (176) PROGRAM:     {P_OPEN_PARENTHESES}
     *       (178) PROGRAM:     {P_CLOSE_PARENTHESES}
     *       (180) PROGRAM:     {P_WORD}
     *       (182) PROGRAM:     {P_NUMBER}
     *       (184) PROGRAM:     {P_WHITESPACE}
     * 
     * 
     * MODE: ML_PREPROCESOR_READER
     * 
     *     BASE MODE SEQUENCE:
     *       END_OF_FILE
     * 
     *     PATTERN-ACTION PAIRS:
     *       (197) ML_PREPROCESOR_READER: {P_BACKSLASH}
     *       (199) ML_PREPROCESOR_READER: {P_PREPROCESSOR_MULTILINE_CONTINUE}
     *       (201) ML_PREPROCESOR_READER: {P_SEMICOLON}
     *       (203) ML_PREPROCESOR_READER: {P_ML_COMMENT_DELIMITER_START}
     *       (205) ML_PREPROCESOR_READER: {P_STRING_DELIMITER}
     *       (207) ML_PREPROCESOR_READER: {P_ONE_LINE_COMMENT}
     *       (209) ML_PREPROCESOR_READER: {P_OPEN_PARENTHESES}
     *       (211) ML_PREPROCESOR_READER: {P_CLOSE_PARENTHESES}
     *       (213) ML_PREPROCESOR_READER: {P_WORD}
     *       (215) ML_PREPROCESOR_READER: {P_NUMBER}
     *       (217) ML_PREPROCESOR_READER: {P_WHITESPACE}
     * 
     * 
     */
#include "depythonize_c_lex"
QUEX_NAMESPACE_MAIN_OPEN
#include <quex/code_base/analyzer/member/basic>
#include <quex/code_base/buffer/Buffer>
#ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
#   include <quex/code_base/token/TokenQueue>
#endif

#ifdef    CONTINUE
#   undef CONTINUE
#endif
#ifdef    RETURN
#   undef RETURN
#endif

#define RETURN   return
#define CONTINUE goto __REENTRY_PREPARATION; 

#ifndef    __QUEX_INFO_LEXEME_NULL_DEFINED
#   define __QUEX_INFO_LEXEME_NULL_DEFINED
    static QUEX_TYPE_CHARACTER  __QuexLexemeNullObject = 0x0;
#endif
#include <quex/code_base/temporary_macros_on>

void  
QUEX_NAME(ML_COMMENT_READER_analyzer_function)(QUEX_TYPE_ANALYZER* me) 
{
    /* NOTE: Different modes correspond to different analyzer functions. The analyzer  
             functions are all located inside the main class as static functions. That  
             means, they are something like 'globals'. They receive a pointer to the   
             lexical analyzer, since static member do not have access to the 'this' pointer.
     */
#   ifdef     self
#       undef self
#   endif
#   define self (*((QUEX_TYPE_ANALYZER*)me))
    /* me = pointer to state of the lexical analyzer */
#   define ML_COMMENT_READER        (QUEX_NAME(ML_COMMENT_READER))
#   define STRING_READER            (QUEX_NAME(STRING_READER))
#   define PROGRAM                  (QUEX_NAME(PROGRAM))
#   define ML_PREPROCESOR_READER    (QUEX_NAME(ML_PREPROCESOR_READER))
    QUEX_TYPE_GOTO_LABEL         last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;
    QUEX_TYPE_CHARACTER_POSITION last_acceptance_input_position = (QUEX_TYPE_CHARACTER*)(0x00);
    QUEX_TYPE_CHARACTER_POSITION* post_context_start_position = 0x0;
    const size_t                 PostContextStartPositionN = (size_t)0;
    QUEX_TYPE_CHARACTER          input = (QUEX_TYPE_CHARACTER)(0x00);

    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE) \
    || defined(QUEX_OPTION_ASSERTS)
    me->DEBUG_analyzer_function_at_entry = me->current_analyzer_function;
#endif
__REENTRY:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY");
    QUEX_NAME(Buffer_mark_lexeme_start)(&me->buffer);
    QUEX_NAME(Buffer_undo_terminating_zero_for_lexeme)(&me->buffer);
    /* state machine */
    /* init-state = 522L
     * 00522() <~ (195, 475)
     *       == '*' ==> 00523
     *       <no epsilon>
     * 00523() <~ (195, 476)
     *       == '/' ==> 00524
     *       <no epsilon>
     * 00524(A, S) <~ (195, 477, A, S)
     *       <no epsilon>
     * 
     */
STATE_522:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_522");

    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input == 42) {
        goto STATE_523;    /* '*' */
    } else {
        goto STATE_522_DROP_OUT;    /* [-oo, ')'] */
    }

STATE_522_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_522_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
/*ATE_522_DROP_OUT_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_522_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

    if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {
        /* NO CHECK 'last_acceptance != -1' --- first state can **never** be an acceptance state */
        goto TERMINAL_END_OF_STREAM;
    }
        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_522_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();


STATE_522_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_522_INPUT");
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    goto STATE_522;
STATE_523:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_523");

STATE_523_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_523_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input == 47) {
        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
        goto TERMINAL_195_DIRECT;    /* '/' */
    } else {
        goto STATE_523_DROP_OUT;    /* [-oo, '.'] */
    }

STATE_523_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_523_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
/*ATE_523_DROP_OUT_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_523_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_523_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();




  /* (*) Terminal states _______________________________________________________*/
  /**/
  /* Acceptance terminal states, i.e. the 'winner patterns'. This means*/
  /* that the last input dropped out of a state where the longest matching*/
  /* pattern was according to the terminal state. The terminal states are */
  /* numbered after the pattern id.*/
  /**/

/* Lexeme descriptions: There is a temporary zero stored at the end of each
 * lexeme. A pointer to the zero provides the Null-lexeme.                     */
#define Lexeme       (me->buffer._lexeme_start_p)
#define LexemeBegin  (me->buffer._lexeme_start_p)
#define LexemeEnd    (me->buffer._input_p)
#define LexemeNull   (&__QuexLexemeNullObject)
#define LexemeL      (me->buffer._input_p - me->buffer._lexeme_start_p)
TERMINAL_195:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_195");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_195_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_195_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 2);
        #   endif
        
        #line 268 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
            /*........................................*/
            if(self.in_preprocessor_block)
              self << ML_PREPROCESOR_READER;
            else
              self << PROGRAM;
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 616 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;



TERMINAL_END_OF_STREAM:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_END_OF_STREAM");

                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
            QUEX_NAME(CounterLineColumnIndentation_on_end_of_file)(&self.counter);
        #   endif
        
        #line 92 "depythonize_c.qx"
        self_send0(QUEX_TKN_TERMINATION);
        
#line 638 "depythonize_c_lex.cpp"
        
        }
                }

     /* End of Stream causes a return from the lexical analyzer, so that no
      * tokens can be filled after the termination token.                    */
     return;          

TERMINAL_FAILURE:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_FAILURE");

me->buffer._input_p = me->buffer._lexeme_start_p;
if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {

    /* Next increment will stop on EOF character. */
}

else {
    /* Step over nomatching character */
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
}

                QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 279 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
          
        
#line 674 "depythonize_c_lex.cpp"
        
        }
                }

     goto __REENTRY_PREPARATION;

#undef Lexeme
#undef LexemeBegin
#undef LexemeEnd
#undef LexemeNull
#undef LexemeL
#ifndef __QUEX_OPTION_USE_COMPUTED_GOTOS
__TERMINAL_ROUTER: {
        /*  if last_acceptance => goto correspondent acceptance terminal state*/
        /*  else               => execute defaul action*/
        switch( last_acceptance ) {
            case 195: goto TERMINAL_195;

            default: goto TERMINAL_FAILURE;; /* nothing matched */
        }
    }
#endif /* __QUEX_OPTION_USE_COMPUTED_GOTOS */

  
__REENTRY_PREPARATION:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY_PREPARATION");

    /* (*) Common point for **restarting** lexical analysis.
     *     at each time when CONTINUE is called at the end of a pattern. */
    
#ifndef   __QUEX_OPTION_PLAIN_ANALYZER_OBJECT
#   ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
    if( QUEX_NAME(TokenQueue_is_full)(&self._token_queue) ) return;
#   else
    if( self.token->type_id() != __QUEX_SETTING_TOKEN_ID_UNINITIALIZED) return;
#   endif
#endif

    last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;


    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */

    /*  If a mode change happened, then the function must first return and
     *  indicate that another mode function is to be called. At this point, 
     *  we to force a 'return' on a mode change. 
     *
     *  Pseudo Code: if( previous_mode != current_mode ) {
     *                   return 0;
     *               }
     *
     *  When the analyzer returns, the caller function has to watch if a mode change
     *  occured. If not it can call this function again.                               */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)     || defined(QUEX_OPTION_ASSERTS)
    if( me->DEBUG_analyzer_function_at_entry != me->current_analyzer_function ) 
#endif
    { 
#if defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)
    QUEX_TOKEN_POLICY_SET_ID(__QUEX_SETTING_TOKEN_ID_UNINITIALIZED);
    return;
#elif defined(QUEX_OPTION_ASSERTS)
    QUEX_ERROR_EXIT("Mode change without immediate return from the lexical analyzer.");
#endif
    }

    goto __REENTRY;

    /* prevent compiler warning 'unused variable': use variables once in a part of the code*/
    /* that is never reached (and deleted by the compiler anyway).*/
    if( 0 == 1 ) {
        int unused = 0;
        unused += (int)ML_COMMENT_READER.id;
        unused += (int)STRING_READER.id;
        unused += (int)PROGRAM.id;
        unused += (int)ML_PREPROCESOR_READER.id;
        unused += (int)__QuexLexemeNullObject;
    }
#   undef ML_COMMENT_READER
#   undef STRING_READER
#   undef PROGRAM
#   undef ML_PREPROCESOR_READER
}
#include <quex/code_base/temporary_macros_off>

#include <quex/code_base/analyzer/member/basic>
#include <quex/code_base/buffer/Buffer>
#ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
#   include <quex/code_base/token/TokenQueue>
#endif

#ifdef    CONTINUE
#   undef CONTINUE
#endif
#ifdef    RETURN
#   undef RETURN
#endif

#define RETURN   return
#define CONTINUE goto __REENTRY_PREPARATION; 

#ifndef    __QUEX_INFO_LEXEME_NULL_DEFINED
#   define __QUEX_INFO_LEXEME_NULL_DEFINED
    static QUEX_TYPE_CHARACTER  __QuexLexemeNullObject = 0x0;
#endif
#include <quex/code_base/temporary_macros_on>

void  
QUEX_NAME(STRING_READER_analyzer_function)(QUEX_TYPE_ANALYZER* me) 
{
    /* NOTE: Different modes correspond to different analyzer functions. The analyzer  
             functions are all located inside the main class as static functions. That  
             means, they are something like 'globals'. They receive a pointer to the   
             lexical analyzer, since static member do not have access to the 'this' pointer.
     */
#   ifdef     self
#       undef self
#   endif
#   define self (*((QUEX_TYPE_ANALYZER*)me))
    /* me = pointer to state of the lexical analyzer */
#   define ML_COMMENT_READER        (QUEX_NAME(ML_COMMENT_READER))
#   define STRING_READER            (QUEX_NAME(STRING_READER))
#   define PROGRAM                  (QUEX_NAME(PROGRAM))
#   define ML_PREPROCESOR_READER    (QUEX_NAME(ML_PREPROCESOR_READER))
    QUEX_TYPE_GOTO_LABEL         last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;
    QUEX_TYPE_CHARACTER_POSITION last_acceptance_input_position = (QUEX_TYPE_CHARACTER*)(0x00);
    QUEX_TYPE_CHARACTER_POSITION* post_context_start_position = 0x0;
    const size_t                 PostContextStartPositionN = (size_t)0;
    QUEX_TYPE_CHARACTER          input = (QUEX_TYPE_CHARACTER)(0x00);

    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE) \
    || defined(QUEX_OPTION_ASSERTS)
    me->DEBUG_analyzer_function_at_entry = me->current_analyzer_function;
#endif
__REENTRY:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY");
    QUEX_NAME(Buffer_mark_lexeme_start)(&me->buffer);
    QUEX_NAME(Buffer_undo_terminating_zero_for_lexeme)(&me->buffer);
    /* state machine */
    /* init-state = 546L
     * 00546() <~ (186, 454), (188, 460), (190, 464), (193, 470)
     *       == [\1, '\t'], [\11, '!'], ['#', '['], [']', oo] ==> 00548
     *       == '"' ==> 00547
     *       == '\' ==> 00549
     *       <no epsilon>
     * 00547(A, S) <~ (190, 465, A, S)
     *       <no epsilon>
     * 00548(A, S) <~ (193, 471, A, S)
     *       <no epsilon>
     * 00549(A, S) <~ (193, 471, A, S), (186, 455), (188, 461)
     *       == '"' ==> 00550
     *       == '\' ==> 00551
     *       <no epsilon>
     * 00550(A, S) <~ (186, 456, A, S)
     *       <no epsilon>
     * 00551(A, S) <~ (188, 462, A, S)
     *       <no epsilon>
     * 
     */
STATE_546:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_546");

    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 34) {
        if( input < 10) {
            if( input < 1) {
                goto STATE_546_DROP_OUT;    /* [-oo, \0] */
            } else {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_193_DIRECT;    /* [\1, '\t'] */
            }
        } else {
            if( input == 10) {
                goto STATE_546_DROP_OUT_DIRECT;    /* '\n' */
            } else {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_193_DIRECT;    /* [\11, '!'] */
            }
        }
    } else {
        if( input < 92) {
            if( input == 34) {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_190_DIRECT;    /* '"' */
            } else {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_193_DIRECT;    /* ['#', '['] */
            }
        } else {
            if( input < 93) {
                goto STATE_549;    /* '\' */
            } else {
                if( input < 9223372036854775807) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                    goto TERMINAL_193_DIRECT;    /* [']', oo] */
                } else {
                    goto STATE_546_DROP_OUT_DIRECT;    /* '' */
                }
            }
        }
    }

STATE_546_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_546_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_546_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_546_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

    if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {
        /* NO CHECK 'last_acceptance != -1' --- first state can **never** be an acceptance state */
        goto TERMINAL_END_OF_STREAM;
    }
        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_546_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();


STATE_546_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_546_INPUT");
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    goto STATE_546;
STATE_549:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_549");

STATE_549_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_549_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "193");
    QUEX_SET_last_acceptance(193);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 35) {
        if( input != 34) {
            goto STATE_549_DROP_OUT;    /* [-oo, '!'] */
        } else {
            QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
            goto TERMINAL_186_DIRECT;    /* '"' */
        }
    } else {
        if( input == 92) {
            QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
            goto TERMINAL_188_DIRECT;    /* '\' */
        } else {
            goto STATE_549_DROP_OUT_DIRECT;    /* ['#', '['] */
        }
    }

STATE_549_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_549_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_549_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_549_DROP_OUT_DIRECT");
            goto TERMINAL_193;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "193");
    QUEX_SET_last_acceptance(193);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_549_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();




  /* (*) Terminal states _______________________________________________________*/
  /**/
  /* Acceptance terminal states, i.e. the 'winner patterns'. This means*/
  /* that the last input dropped out of a state where the longest matching*/
  /* pattern was according to the terminal state. The terminal states are */
  /* numbered after the pattern id.*/
  /**/

/* Lexeme descriptions: There is a temporary zero stored at the end of each
 * lexeme. A pointer to the zero provides the Null-lexeme.                     */
#define Lexeme       (me->buffer._lexeme_start_p)
#define LexemeBegin  (me->buffer._lexeme_start_p)
#define LexemeEnd    (me->buffer._input_p)
#define LexemeNull   (&__QuexLexemeNullObject)
#define LexemeL      (me->buffer._input_p - me->buffer._lexeme_start_p)
TERMINAL_193:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_193");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_193_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_193_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline)(&self.counter, Lexeme, LexemeL);
        #   endif
        
        #line 242 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
          
        
#line 1014 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_186:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_186");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_186_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_186_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 2);
        #   endif
        
        #line 223 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
          
        
#line 1042 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_188:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_188");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_188_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_188_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 2);
        #   endif
        
        #line 227 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
          
        
#line 1070 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_190:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_190");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_190_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_190_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 231 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
            /*........................................*/
            if(self.in_preprocessor_block)
              self << ML_PREPROCESOR_READER;
            else
              self << PROGRAM;
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 1105 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;



TERMINAL_END_OF_STREAM:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_END_OF_STREAM");

                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
            QUEX_NAME(CounterLineColumnIndentation_on_end_of_file)(&self.counter);
        #   endif
        
        #line 92 "depythonize_c.qx"
        self_send0(QUEX_TKN_TERMINATION);
        
#line 1127 "depythonize_c_lex.cpp"
        
        }
                }

     /* End of Stream causes a return from the lexical analyzer, so that no
      * tokens can be filled after the termination token.                    */
     return;          

TERMINAL_FAILURE:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_FAILURE");

me->buffer._input_p = me->buffer._lexeme_start_p;
if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {

    /* Next increment will stop on EOF character. */
}

else {
    /* Step over nomatching character */
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
}

                QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 246 "depythonize_c.qx"
        
            self.accumulator.add(Lexeme,LexemeEnd);
          
        
#line 1163 "depythonize_c_lex.cpp"
        
        }
                }

     goto __REENTRY_PREPARATION;

#undef Lexeme
#undef LexemeBegin
#undef LexemeEnd
#undef LexemeNull
#undef LexemeL
#ifndef __QUEX_OPTION_USE_COMPUTED_GOTOS
__TERMINAL_ROUTER: {
        /*  if last_acceptance => goto correspondent acceptance terminal state*/
        /*  else               => execute defaul action*/
        switch( last_acceptance ) {
            case 193: goto TERMINAL_193;
            case 186: goto TERMINAL_186;
            case 188: goto TERMINAL_188;
            case 190: goto TERMINAL_190;

            default: goto TERMINAL_FAILURE;; /* nothing matched */
        }
    }
#endif /* __QUEX_OPTION_USE_COMPUTED_GOTOS */

  
__REENTRY_PREPARATION:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY_PREPARATION");

    /* (*) Common point for **restarting** lexical analysis.
     *     at each time when CONTINUE is called at the end of a pattern. */
    
#ifndef   __QUEX_OPTION_PLAIN_ANALYZER_OBJECT
#   ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
    if( QUEX_NAME(TokenQueue_is_full)(&self._token_queue) ) return;
#   else
    if( self.token->type_id() != __QUEX_SETTING_TOKEN_ID_UNINITIALIZED) return;
#   endif
#endif

    last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;


    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */

    /*  If a mode change happened, then the function must first return and
     *  indicate that another mode function is to be called. At this point, 
     *  we to force a 'return' on a mode change. 
     *
     *  Pseudo Code: if( previous_mode != current_mode ) {
     *                   return 0;
     *               }
     *
     *  When the analyzer returns, the caller function has to watch if a mode change
     *  occured. If not it can call this function again.                               */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)     || defined(QUEX_OPTION_ASSERTS)
    if( me->DEBUG_analyzer_function_at_entry != me->current_analyzer_function ) 
#endif
    { 
#if defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)
    QUEX_TOKEN_POLICY_SET_ID(__QUEX_SETTING_TOKEN_ID_UNINITIALIZED);
    return;
#elif defined(QUEX_OPTION_ASSERTS)
    QUEX_ERROR_EXIT("Mode change without immediate return from the lexical analyzer.");
#endif
    }

    goto __REENTRY;

    /* prevent compiler warning 'unused variable': use variables once in a part of the code*/
    /* that is never reached (and deleted by the compiler anyway).*/
    if( 0 == 1 ) {
        int unused = 0;
        unused += (int)ML_COMMENT_READER.id;
        unused += (int)STRING_READER.id;
        unused += (int)PROGRAM.id;
        unused += (int)ML_PREPROCESOR_READER.id;
        unused += (int)__QuexLexemeNullObject;
    }
#   undef ML_COMMENT_READER
#   undef STRING_READER
#   undef PROGRAM
#   undef ML_PREPROCESOR_READER
}
#include <quex/code_base/temporary_macros_off>

#include <quex/code_base/analyzer/member/basic>
#include <quex/code_base/buffer/Buffer>
#ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
#   include <quex/code_base/token/TokenQueue>
#endif

#ifdef    CONTINUE
#   undef CONTINUE
#endif
#ifdef    RETURN
#   undef RETURN
#endif

#define RETURN   return
#define CONTINUE goto __REENTRY_PREPARATION; 

#ifndef    __QUEX_INFO_LEXEME_NULL_DEFINED
#   define __QUEX_INFO_LEXEME_NULL_DEFINED
    static QUEX_TYPE_CHARACTER  __QuexLexemeNullObject = 0x0;
#endif
#include <quex/code_base/temporary_macros_on>

void  
QUEX_NAME(PROGRAM_analyzer_function)(QUEX_TYPE_ANALYZER* me) 
{
    /* NOTE: Different modes correspond to different analyzer functions. The analyzer  
             functions are all located inside the main class as static functions. That  
             means, they are something like 'globals'. They receive a pointer to the   
             lexical analyzer, since static member do not have access to the 'this' pointer.
     */
#   ifdef     self
#       undef self
#   endif
#   define self (*((QUEX_TYPE_ANALYZER*)me))
    /* me = pointer to state of the lexical analyzer */
#   define ML_COMMENT_READER        (QUEX_NAME(ML_COMMENT_READER))
#   define STRING_READER            (QUEX_NAME(STRING_READER))
#   define PROGRAM                  (QUEX_NAME(PROGRAM))
#   define ML_PREPROCESOR_READER    (QUEX_NAME(ML_PREPROCESOR_READER))
    QUEX_TYPE_GOTO_LABEL         last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;
    QUEX_TYPE_CHARACTER_POSITION last_acceptance_input_position = (QUEX_TYPE_CHARACTER*)(0x00);
    QUEX_TYPE_CHARACTER_POSITION* post_context_start_position = 0x0;
    const size_t                 PostContextStartPositionN = (size_t)0;
    QUEX_TYPE_CHARACTER          input = (QUEX_TYPE_CHARACTER)(0x00);

    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE) \
    || defined(QUEX_OPTION_ASSERTS)
    me->DEBUG_analyzer_function_at_entry = me->current_analyzer_function;
#endif
__REENTRY:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY");
    QUEX_NAME(Buffer_mark_lexeme_start)(&me->buffer);
    QUEX_NAME(Buffer_undo_terminating_zero_for_lexeme)(&me->buffer);
    /* state machine */
    /* init-state = 603L
     * 00603() <~ (164, 404), (166, 408), (168, 413), (170, 418), (172, 423), (175, 429), (176, 433), (178, 437), (180, 441), (182, 445), (184, 449)
     *       == '\t', ' ' ==> 00605
     *       == '\n' ==> 00608
     *       == '"' ==> 00613
     *       == '#' ==> 00607
     *       == '(' ==> 00610
     *       == ')' ==> 00604
     *       == '/' ==> 00611
     *       == ['0', '9'] ==> 00612
     *       == ';' ==> 00614
     *       == ['A', 'Z'], '_', ['a', 'z'] ==> 00606
     *       == '\' ==> 00609
     *       <no epsilon>
     * 00608(A, S) <~ (184, 450, A, S)
     *       <no epsilon>
     * 00609(A, S) <~ (164, 405, A, S)
     *       <no epsilon>
     * 00610(A, S) <~ (176, 434, A, S)
     *       <no epsilon>
     * 00611() <~ (168, 414), (172, 424)
     *       == '*' ==> 00616
     *       == '/' ==> 00615
     *       <no epsilon>
     * 00616(A, S) <~ (168, 415, A, S)
     *       <no epsilon>
     * 00615(A, S) <~ (172, 425, A, S)
     *       == [\1, '\t'], [\11, oo] ==> 00615
     *       <no epsilon>
     * 00612(A, S) <~ (182, 446, A, S)
     *       == ['0', '9'] ==> 00612
     *       <no epsilon>
     * 00613(A, S) <~ (170, 419, A, S)
     *       <no epsilon>
     * 00614(A, S) <~ (166, 409, A, S)
     *       <no epsilon>
     * 00604(A, S) <~ (178, 438, A, S)
     *       <no epsilon>
     * 00605(A, S) <~ (184, 450, A, S), (175, 429)
     *       == '\t', ' ' ==> 00617
     *       == '#' ==> 00607
     *       <no epsilon>
     * 00617() <~ (175, 429)
     *       == '\t', ' ' ==> 00617
     *       == '#' ==> 00607
     *       <no epsilon>
     * 00607(A, S) <~ (175, 430, A, S)
     *       <no epsilon>
     * 00606(A, S) <~ (180, 442, A, S)
     *       == ['0', '9'], ['A', 'Z'], '_', ['a', 'z'] ==> 00606
     *       <no epsilon>
     * 
     */
STATE_603:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_603");

    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 47) {
        if( input < 34) {
            if( input < 11) {
                if( input < 9) {
                    goto STATE_603_DROP_OUT;    /* [-oo, \8] */
                } else {
                    if( input == 9) {
                        goto STATE_605;    /* '\t' */
                    } else {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_184_DIRECT;    /* '\n' */
                    }
                }
            } else {
                if( input == 32) {
                    goto STATE_605;    /* ' ' */
                } else {
                    goto STATE_603_DROP_OUT_DIRECT;    /* [\11, \31] */
                }
            }
        } else {
            if( input < 40) {
                if( input < 35) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_170_DIRECT;    /* '"' */
                } else {
                    if( input == 35) {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_175_DIRECT;    /* '#' */
                    } else {
                        goto STATE_603_DROP_OUT_DIRECT;    /* ['$', '''] */
                    }
                }
            } else {
                if( input < 41) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_176_DIRECT;    /* '(' */
                } else {
                    if( input == 41) {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_178_DIRECT;    /* ')' */
                    } else {
                        goto STATE_603_DROP_OUT_DIRECT;    /* ['*', '.'] */
                    }
                }
            }
        }
    } else {
        if( input < 91) {
            if( input < 59) {
                if( input < 48) {
                    goto STATE_611;    /* '/' */
                } else {
                    if( input != 58) {
                        goto STATE_612;    /* ['0', '9'] */
                    } else {
                        goto STATE_603_DROP_OUT_DIRECT;    /* ':' */
                    }
                }
            } else {
                if( input < 60) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_166_DIRECT;    /* ';' */
                } else {
                    if( input < 65) {
                        goto STATE_603_DROP_OUT_DIRECT;    /* ['<', '@'] */
                    } else {
                        goto STATE_606;    /* ['A', 'Z'] */
                    }
                }
            }
        } else {
            if( input < 95) {
                if( input == 92) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                    goto TERMINAL_164_DIRECT;    /* '\' */
                } else {
                    goto STATE_603_DROP_OUT_DIRECT;    /* '[' */
                }
            } else {
                if( input < 97) {
                    if( input == 95) {
                        goto STATE_606;    /* '_' */
                    } else {
                        goto STATE_603_DROP_OUT_DIRECT;    /* '`' */
                    }
                } else {
                    if( input < 123) {
                        goto STATE_606;    /* ['a', 'z'] */
                    } else {
                        goto STATE_603_DROP_OUT_DIRECT;    /* ['{', oo] */
                    }
                }
            }
        }
    }

STATE_603_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_603_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_603_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_603_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

    if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {
        /* NO CHECK 'last_acceptance != -1' --- first state can **never** be an acceptance state */
        goto TERMINAL_END_OF_STREAM;
    }
        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_603_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();


STATE_603_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_603_INPUT");
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    goto STATE_603;
STATE_611:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_611");

STATE_611_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_611_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 43) {
        if( input != 42) {
            goto STATE_611_DROP_OUT;    /* [-oo, ')'] */
        } else {
            QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
            goto TERMINAL_168_DIRECT;    /* '*' */
        }
    } else {
        if( input == 47) {
            goto STATE_615;    /* '/' */
        } else {
            goto STATE_611_DROP_OUT_DIRECT;    /* ['+', '.'] */
        }
    }

STATE_611_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_611_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_611_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_611_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_611_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_612:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_612");

STATE_612_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_612_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "182");
    QUEX_SET_last_acceptance(182);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input >= 48 && input < 58 ) {
        goto STATE_612;    /* ['0', '9'] */
    } else {
        goto STATE_612_DROP_OUT;    /* [-oo, '/'] */
    }

STATE_612_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_612_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
/*ATE_612_DROP_OUT_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_612_DROP_OUT_DIRECT");
            goto TERMINAL_182;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "182");
    QUEX_SET_last_acceptance(182);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_612_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_615:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_615");

STATE_615_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_615_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "172");
    QUEX_SET_last_acceptance(172);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 10) {
        if( input < 1) {
            goto STATE_615_DROP_OUT;    /* [-oo, \0] */
        } else {
            goto STATE_615;    /* [\1, '\t'] */
        }
    } else {
        if( input >= 11 && input < 9223372036854775807 ) {
            goto STATE_615;    /* [\11, oo] */
        } else {
            goto STATE_615_DROP_OUT_DIRECT;    /* '\n' */
        }
    }

STATE_615_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_615_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_615_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_615_DROP_OUT_DIRECT");
            goto TERMINAL_172;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "172");
    QUEX_SET_last_acceptance(172);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_615_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_617:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_617");

STATE_617_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_617_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 32) {
        if( input == 9) {
            goto STATE_617;    /* '\t' */
        } else {
            goto STATE_617_DROP_OUT;    /* [-oo, \8] */
        }
    } else {
        if( input < 35) {
            if( input == 32) {
                goto STATE_617;    /* ' ' */
            } else {
                goto STATE_617_DROP_OUT_DIRECT;    /* ['!', '"'] */
            }
        } else {
            if( input == 35) {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_175_DIRECT;    /* '#' */
            } else {
                goto STATE_617_DROP_OUT_DIRECT;    /* ['$', oo] */
            }
        }
    }

STATE_617_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_617_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_617_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_617_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_617_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_605:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_605");

STATE_605_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_605_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "184");
    QUEX_SET_last_acceptance(184);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 32) {
        if( input == 9) {
            goto STATE_617;    /* '\t' */
        } else {
            goto STATE_605_DROP_OUT;    /* [-oo, \8] */
        }
    } else {
        if( input < 35) {
            if( input == 32) {
                goto STATE_617;    /* ' ' */
            } else {
                goto STATE_605_DROP_OUT_DIRECT;    /* ['!', '"'] */
            }
        } else {
            if( input == 35) {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_175_DIRECT;    /* '#' */
            } else {
                goto STATE_605_DROP_OUT_DIRECT;    /* ['$', oo] */
            }
        }
    }

STATE_605_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_605_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_605_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_605_DROP_OUT_DIRECT");
            goto TERMINAL_184;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "184");
    QUEX_SET_last_acceptance(184);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_605_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_606:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_606");

STATE_606_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_606_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "180");
    QUEX_SET_last_acceptance(180);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 91) {
        if( input < 58) {
            if( input < 48) {
                goto STATE_606_DROP_OUT;    /* [-oo, '/'] */
            } else {
                goto STATE_606;    /* ['0', '9'] */
            }
        } else {
            if( input < 65) {
                goto STATE_606_DROP_OUT_DIRECT;    /* [':', '@'] */
            } else {
                goto STATE_606;    /* ['A', 'Z'] */
            }
        }
    } else {
        if( input < 96) {
            if( input != 95) {
                goto STATE_606_DROP_OUT_DIRECT;    /* ['[', '^'] */
            } else {
                goto STATE_606;    /* '_' */
            }
        } else {
            if( input >= 97 && input < 123 ) {
                goto STATE_606;    /* ['a', 'z'] */
            } else {
                goto STATE_606_DROP_OUT_DIRECT;    /* '`' */
            }
        }
    }

STATE_606_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_606_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_606_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_606_DROP_OUT_DIRECT");
            goto TERMINAL_180;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "180");
    QUEX_SET_last_acceptance(180);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_606_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();




  /* (*) Terminal states _______________________________________________________*/
  /**/
  /* Acceptance terminal states, i.e. the 'winner patterns'. This means*/
  /* that the last input dropped out of a state where the longest matching*/
  /* pattern was according to the terminal state. The terminal states are */
  /* numbered after the pattern id.*/
  /**/

/* Lexeme descriptions: There is a temporary zero stored at the end of each
 * lexeme. A pointer to the zero provides the Null-lexeme.                     */
#define Lexeme       (me->buffer._lexeme_start_p)
#define LexemeBegin  (me->buffer._lexeme_start_p)
#define LexemeEnd    (me->buffer._input_p)
#define LexemeNull   (&__QuexLexemeNullObject)
#define LexemeL      (me->buffer._input_p - me->buffer._lexeme_start_p)
TERMINAL_164:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_164");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_164_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_164_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 141 "depythonize_c.qx"
        
            self.send(QUEX_TKN_BACKSLASH,Lexeme);
            self.allow_opening_indentation_f = false;
            RETURN;
          
        
#line 1854 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_166:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_166");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_166_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_166_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 147 "depythonize_c.qx"
        self_send1(QUEX_TKN_SEMICOLON, Lexeme);
        CONTINUE;
        
#line 1881 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_168:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_168");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_168_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_168_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 2);
        #   endif
        
        #line 149 "depythonize_c.qx"
        
            self << ML_COMMENT_READER;
            self.accumulator.add(Lexeme,LexemeEnd);
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 1912 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_170:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_170");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_170_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_170_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 156 "depythonize_c.qx"
        
            self << STRING_READER;
            self.accumulator.add(Lexeme,LexemeEnd);
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 1943 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_172:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_172");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_172_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_172_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 163 "depythonize_c.qx"
        self_send1(QUEX_TKN_COMMENT, Lexeme);
        CONTINUE;
        
#line 1969 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_175:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_175");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_175_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_175_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline)(&self.counter, Lexeme, LexemeL);
        #   endif
        
        #line 167 "depythonize_c.qx"
        
            //self.send(QUEX_TKN_NEWLINE);
            self << ML_PREPROCESOR_READER;
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            self.send(QUEX_TKN_PREPROCESSOR_MULTILINE_START,Lexeme);
            return;
          
        
#line 2001 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_176:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_176");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_176_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_176_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 175 "depythonize_c.qx"
        
            if(self.parentheses_counter == 0)
              self.send(QUEX_TKN_START_PARENTHESIS_BLOCK,Lexeme);
            else
              self.send(QUEX_TKN_CODE,Lexeme);
            self.parentheses_counter += 1;
            RETURN;
          
        
#line 2034 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_178:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_178");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_178_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_178_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 183 "depythonize_c.qx"
        
            self.parentheses_counter -= 1;
            if(self.parentheses_counter == 0)
              self.send(QUEX_TKN_END_PARENTHESIS_BLOCK,Lexeme);
            else
              self.send(QUEX_TKN_CODE,Lexeme);
            RETURN;
          
        
#line 2067 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_180:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_180");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_180_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_180_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 192 "depythonize_c.qx"
        self_send1(QUEX_TKN_WORD, Lexeme);
        CONTINUE;
        
#line 2093 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_182:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_182");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_182_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_182_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 194 "depythonize_c.qx"
        self_send1(QUEX_TKN_NUMBER, Lexeme);
        CONTINUE;
        
#line 2119 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_184:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_184");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_184_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_184_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 196 "depythonize_c.qx"
        
            if( *Lexeme == '\n')
              self.send(QUEX_TKN_NEWLINE,Lexeme);
            else
              self.send(QUEX_TKN_WHITESPACE,Lexeme);
          
        
#line 2150 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;



TERMINAL_END_OF_STREAM:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_END_OF_STREAM");

                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
            QUEX_NAME(CounterLineColumnIndentation_on_end_of_file)(&self.counter);
        #   endif
        
        #line 92 "depythonize_c.qx"
        self_send0(QUEX_TKN_TERMINATION);
        
#line 2172 "depythonize_c_lex.cpp"
        
        }
                }

     /* End of Stream causes a return from the lexical analyzer, so that no
      * tokens can be filled after the termination token.                    */
     return;          

TERMINAL_FAILURE:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_FAILURE");

me->buffer._input_p = me->buffer._lexeme_start_p;
if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {

    /* Next increment will stop on EOF character. */
}

else {
    /* Step over nomatching character */
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
}

                QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 203 "depythonize_c.qx"
        
            self.send(QUEX_TKN_CODE,Lexeme);
          
        
#line 2208 "depythonize_c_lex.cpp"
        
        }
                }

     goto __REENTRY_PREPARATION;

#undef Lexeme
#undef LexemeBegin
#undef LexemeEnd
#undef LexemeNull
#undef LexemeL
#ifndef __QUEX_OPTION_USE_COMPUTED_GOTOS
__TERMINAL_ROUTER: {
        /*  if last_acceptance => goto correspondent acceptance terminal state*/
        /*  else               => execute defaul action*/
        switch( last_acceptance ) {
            case 164: goto TERMINAL_164;
            case 166: goto TERMINAL_166;
            case 168: goto TERMINAL_168;
            case 170: goto TERMINAL_170;
            case 172: goto TERMINAL_172;
            case 175: goto TERMINAL_175;
            case 176: goto TERMINAL_176;
            case 178: goto TERMINAL_178;
            case 180: goto TERMINAL_180;
            case 182: goto TERMINAL_182;
            case 184: goto TERMINAL_184;

            default: goto TERMINAL_FAILURE;; /* nothing matched */
        }
    }
#endif /* __QUEX_OPTION_USE_COMPUTED_GOTOS */

  
__REENTRY_PREPARATION:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY_PREPARATION");

    /* (*) Common point for **restarting** lexical analysis.
     *     at each time when CONTINUE is called at the end of a pattern. */
    
#ifndef   __QUEX_OPTION_PLAIN_ANALYZER_OBJECT
#   ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
    if( QUEX_NAME(TokenQueue_is_full)(&self._token_queue) ) return;
#   else
    if( self.token->type_id() != __QUEX_SETTING_TOKEN_ID_UNINITIALIZED) return;
#   endif
#endif

    last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;


    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */

    /*  If a mode change happened, then the function must first return and
     *  indicate that another mode function is to be called. At this point, 
     *  we to force a 'return' on a mode change. 
     *
     *  Pseudo Code: if( previous_mode != current_mode ) {
     *                   return 0;
     *               }
     *
     *  When the analyzer returns, the caller function has to watch if a mode change
     *  occured. If not it can call this function again.                               */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)     || defined(QUEX_OPTION_ASSERTS)
    if( me->DEBUG_analyzer_function_at_entry != me->current_analyzer_function ) 
#endif
    { 
#if defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)
    QUEX_TOKEN_POLICY_SET_ID(__QUEX_SETTING_TOKEN_ID_UNINITIALIZED);
    return;
#elif defined(QUEX_OPTION_ASSERTS)
    QUEX_ERROR_EXIT("Mode change without immediate return from the lexical analyzer.");
#endif
    }

    goto __REENTRY;

    /* prevent compiler warning 'unused variable': use variables once in a part of the code*/
    /* that is never reached (and deleted by the compiler anyway).*/
    if( 0 == 1 ) {
        int unused = 0;
        unused += (int)ML_COMMENT_READER.id;
        unused += (int)STRING_READER.id;
        unused += (int)PROGRAM.id;
        unused += (int)ML_PREPROCESOR_READER.id;
        unused += (int)__QuexLexemeNullObject;
    }
#   undef ML_COMMENT_READER
#   undef STRING_READER
#   undef PROGRAM
#   undef ML_PREPROCESOR_READER
}
#include <quex/code_base/temporary_macros_off>

#include <quex/code_base/analyzer/member/basic>
#include <quex/code_base/buffer/Buffer>
#ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
#   include <quex/code_base/token/TokenQueue>
#endif

#ifdef    CONTINUE
#   undef CONTINUE
#endif
#ifdef    RETURN
#   undef RETURN
#endif

#define RETURN   return
#define CONTINUE goto __REENTRY_PREPARATION; 

#ifndef    __QUEX_INFO_LEXEME_NULL_DEFINED
#   define __QUEX_INFO_LEXEME_NULL_DEFINED
    static QUEX_TYPE_CHARACTER  __QuexLexemeNullObject = 0x0;
#endif
#include <quex/code_base/temporary_macros_on>

void  
QUEX_NAME(ML_PREPROCESOR_READER_analyzer_function)(QUEX_TYPE_ANALYZER* me) 
{
    /* NOTE: Different modes correspond to different analyzer functions. The analyzer  
             functions are all located inside the main class as static functions. That  
             means, they are something like 'globals'. They receive a pointer to the   
             lexical analyzer, since static member do not have access to the 'this' pointer.
     */
#   ifdef     self
#       undef self
#   endif
#   define self (*((QUEX_TYPE_ANALYZER*)me))
    /* me = pointer to state of the lexical analyzer */
#   define ML_COMMENT_READER        (QUEX_NAME(ML_COMMENT_READER))
#   define STRING_READER            (QUEX_NAME(STRING_READER))
#   define PROGRAM                  (QUEX_NAME(PROGRAM))
#   define ML_PREPROCESOR_READER    (QUEX_NAME(ML_PREPROCESOR_READER))
    QUEX_TYPE_GOTO_LABEL         last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;
    QUEX_TYPE_CHARACTER_POSITION last_acceptance_input_position = (QUEX_TYPE_CHARACTER*)(0x00);
    QUEX_TYPE_CHARACTER_POSITION* post_context_start_position = 0x0;
    const size_t                 PostContextStartPositionN = (size_t)0;
    QUEX_TYPE_CHARACTER          input = (QUEX_TYPE_CHARACTER)(0x00);

    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE) \
    || defined(QUEX_OPTION_ASSERTS)
    me->DEBUG_analyzer_function_at_entry = me->current_analyzer_function;
#endif
__REENTRY:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY");
    QUEX_NAME(Buffer_mark_lexeme_start)(&me->buffer);
    QUEX_NAME(Buffer_undo_terminating_zero_for_lexeme)(&me->buffer);
    /* state machine */
    /* init-state = 672L
     * 00672() <~ (197, 479), (199, 485), (201, 490), (203, 493), (205, 497), (207, 500), (209, 504), (211, 507), (213, 510), (215, 513), (217, 516)
     *       == '\t', ' ' ==> 00680
     *       == '\n' ==> 00677
     *       == '"' ==> 00674
     *       == '(' ==> 00675
     *       == ')' ==> 00676
     *       == '/' ==> 00678
     *       == ['0', '9'] ==> 00673
     *       == ';' ==> 00681
     *       == ['A', 'Z'], '_', ['a', 'z'] ==> 00682
     *       == '\' ==> 00679
     *       <no epsilon>
     * 00673(A, S) <~ (215, 514, A, S)
     *       == ['0', '9'] ==> 00673
     *       <no epsilon>
     * 00674(A, S) <~ (205, 498, A, S)
     *       <no epsilon>
     * 00675(A, S) <~ (209, 505, A, S)
     *       <no epsilon>
     * 00676(A, S) <~ (211, 508, A, S)
     *       <no epsilon>
     * 00677(A, S) <~ (217, 517, A, S)
     *       <no epsilon>
     * 00678() <~ (203, 494), (207, 501)
     *       == '*' ==> 00687
     *       == '/' ==> 00686
     *       <no epsilon>
     * 00686(A, S) <~ (207, 502, A, S)
     *       == [\1, '\t'], [\11, oo] ==> 00686
     *       <no epsilon>
     * 00687(A, S) <~ (203, 495, A, S)
     *       <no epsilon>
     * 00679(A, S) <~ (197, 480, A, S)
     *       <no epsilon>
     * 00680(A, S) <~ (217, 517, A, S), (199, 486)
     *       == '\t', ' ' ==> 00684
     *       == '\' ==> 00683
     *       <no epsilon>
     * 00683() <~ (199, 487)
     *       == '\t', ' ' ==> 00683
     *       == '\n' ==> 00685
     *       <no epsilon>
     * 00685(A, S) <~ (199, 488, A, S)
     *       <no epsilon>
     * 00684() <~ (199, 486)
     *       == '\t', ' ' ==> 00684
     *       == '\' ==> 00683
     *       <no epsilon>
     * 00681(A, S) <~ (201, 491, A, S)
     *       <no epsilon>
     * 00682(A, S) <~ (213, 511, A, S)
     *       == ['0', '9'], ['A', 'Z'], '_', ['a', 'z'] ==> 00682
     *       <no epsilon>
     * 
     */
STATE_672:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_672");

    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 48) {
        if( input < 34) {
            if( input < 11) {
                if( input < 9) {
                    goto STATE_672_DROP_OUT;    /* [-oo, \8] */
                } else {
                    if( input == 9) {
                        goto STATE_680;    /* '\t' */
                    } else {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_217_DIRECT;    /* '\n' */
                    }
                }
            } else {
                if( input == 32) {
                    goto STATE_680;    /* ' ' */
                } else {
                    goto STATE_672_DROP_OUT_DIRECT;    /* [\11, \31] */
                }
            }
        } else {
            if( input < 41) {
                if( input < 35) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_205_DIRECT;    /* '"' */
                } else {
                    if( input != 40) {
                        goto STATE_672_DROP_OUT_DIRECT;    /* ['#', '''] */
                    } else {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_209_DIRECT;    /* '(' */
                    }
                }
            } else {
                if( input < 42) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_211_DIRECT;    /* ')' */
                } else {
                    if( input != 47) {
                        goto STATE_672_DROP_OUT_DIRECT;    /* ['*', '.'] */
                    } else {
                        goto STATE_678;    /* '/' */
                    }
                }
            }
        }
    } else {
        if( input < 92) {
            if( input < 60) {
                if( input < 58) {
                    goto STATE_673;    /* ['0', '9'] */
                } else {
                    if( input == 58) {
                        goto STATE_672_DROP_OUT_DIRECT;    /* ':' */
                    } else {
                        QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_201_DIRECT;    /* ';' */
                    }
                }
            } else {
                if( input >= 65 && input < 91 ) {
                    goto STATE_682;    /* ['A', 'Z'] */
                } else {
                    goto STATE_672_DROP_OUT_DIRECT;    /* ['<', '@'] */
                }
            }
        } else {
            if( input < 96) {
                if( input < 93) {
                    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                        goto TERMINAL_197_DIRECT;    /* '\' */
                } else {
                    if( input != 95) {
                        goto STATE_672_DROP_OUT_DIRECT;    /* [']', '^'] */
                    } else {
                        goto STATE_682;    /* '_' */
                    }
                }
            } else {
                if( input >= 97 && input < 123 ) {
                    goto STATE_682;    /* ['a', 'z'] */
                } else {
                    goto STATE_672_DROP_OUT_DIRECT;    /* '`' */
                }
            }
        }
    }

STATE_672_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_672_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_672_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_672_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

    if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {
        /* NO CHECK 'last_acceptance != -1' --- first state can **never** be an acceptance state */
        goto TERMINAL_END_OF_STREAM;
    }
        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_672_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();


STATE_672_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_672_INPUT");
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    goto STATE_672;
STATE_673:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_673");

STATE_673_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_673_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "215");
    QUEX_SET_last_acceptance(215);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input >= 48 && input < 58 ) {
        goto STATE_673;    /* ['0', '9'] */
    } else {
        goto STATE_673_DROP_OUT;    /* [-oo, '/'] */
    }

STATE_673_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_673_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
/*ATE_673_DROP_OUT_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_673_DROP_OUT_DIRECT");
            goto TERMINAL_215;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "215");
    QUEX_SET_last_acceptance(215);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_673_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_678:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_678");

STATE_678_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_678_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 43) {
        if( input != 42) {
            goto STATE_678_DROP_OUT;    /* [-oo, ')'] */
        } else {
            QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
            goto TERMINAL_203_DIRECT;    /* '*' */
        }
    } else {
        if( input == 47) {
            goto STATE_686;    /* '/' */
        } else {
            goto STATE_678_DROP_OUT_DIRECT;    /* ['+', '.'] */
        }
    }

STATE_678_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_678_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_678_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_678_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_678_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_680:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_680");

STATE_680_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_680_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "217");
    QUEX_SET_last_acceptance(217);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 32) {
        if( input == 9) {
            goto STATE_684;    /* '\t' */
        } else {
            goto STATE_680_DROP_OUT;    /* [-oo, \8] */
        }
    } else {
        if( input < 92) {
            if( input == 32) {
                goto STATE_684;    /* ' ' */
            } else {
                goto STATE_680_DROP_OUT_DIRECT;    /* ['!', '['] */
            }
        } else {
            if( input == 92) {
                goto STATE_683;    /* '\' */
            } else {
                goto STATE_680_DROP_OUT_DIRECT;    /* [']', oo] */
            }
        }
    }

STATE_680_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_680_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_680_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_680_DROP_OUT_DIRECT");
            goto TERMINAL_217;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "217");
    QUEX_SET_last_acceptance(217);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_680_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_682:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_682");

STATE_682_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_682_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "213");
    QUEX_SET_last_acceptance(213);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 91) {
        if( input < 58) {
            if( input < 48) {
                goto STATE_682_DROP_OUT;    /* [-oo, '/'] */
            } else {
                goto STATE_682;    /* ['0', '9'] */
            }
        } else {
            if( input < 65) {
                goto STATE_682_DROP_OUT_DIRECT;    /* [':', '@'] */
            } else {
                goto STATE_682;    /* ['A', 'Z'] */
            }
        }
    } else {
        if( input < 96) {
            if( input != 95) {
                goto STATE_682_DROP_OUT_DIRECT;    /* ['[', '^'] */
            } else {
                goto STATE_682;    /* '_' */
            }
        } else {
            if( input >= 97 && input < 123 ) {
                goto STATE_682;    /* ['a', 'z'] */
            } else {
                goto STATE_682_DROP_OUT_DIRECT;    /* '`' */
            }
        }
    }

STATE_682_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_682_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_682_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_682_DROP_OUT_DIRECT");
            goto TERMINAL_213;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "213");
    QUEX_SET_last_acceptance(213);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_682_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_683:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_683");

STATE_683_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_683_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 11) {
        if( input < 9) {
            goto STATE_683_DROP_OUT;    /* [-oo, \8] */
        } else {
            if( input == 9) {
                goto STATE_683;    /* '\t' */
            } else {
                QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
                goto TERMINAL_199_DIRECT;    /* '\n' */
            }
        }
    } else {
        if( input == 32) {
            goto STATE_683;    /* ' ' */
        } else {
            goto STATE_683_DROP_OUT_DIRECT;    /* [\11, \31] */
        }
    }

STATE_683_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_683_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_683_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_683_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_683_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_684:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_684");

STATE_684_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_684_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    if( input < 32) {
        if( input == 9) {
            goto STATE_684;    /* '\t' */
        } else {
            goto STATE_684_DROP_OUT;    /* [-oo, \8] */
        }
    } else {
        if( input < 92) {
            if( input == 32) {
                goto STATE_684;    /* ' ' */
            } else {
                goto STATE_684_DROP_OUT_DIRECT;    /* ['!', '['] */
            }
        } else {
            if( input == 92) {
                goto STATE_683;    /* '\' */
            } else {
                goto STATE_684_DROP_OUT_DIRECT;    /* [']', oo] */
            }
        }
    }

STATE_684_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_684_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_684_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_684_DROP_OUT_DIRECT");
        QUEX_GOTO_last_acceptance();

    }

        QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_684_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();



STATE_686:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_686");

STATE_686_INPUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_686_INPUT");

    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
    input = QUEX_NAME(Buffer_input_get)(&me->buffer);
    QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "207");
    QUEX_SET_last_acceptance(207);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    if( input < 10) {
        if( input < 1) {
            goto STATE_686_DROP_OUT;    /* [-oo, \0] */
        } else {
            goto STATE_686;    /* [\1, '\t'] */
        }
    } else {
        if( input >= 11 && input < 9223372036854775807 ) {
            goto STATE_686;    /* [\11, oo] */
        } else {
            goto STATE_686_DROP_OUT_DIRECT;    /* '\n' */
        }
    }

STATE_686_DROP_OUT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_686_DROP_OUT");
    if( input != QUEX_SETTING_BUFFER_LIMIT_CODE ) {
STATE_686_DROP_OUT_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: STATE_686_DROP_OUT_DIRECT");
            goto TERMINAL_207;
    }

        QUEX_DEBUG_PRINT2(&me->buffer, "ACCEPTANCE: %s", "207");
    QUEX_SET_last_acceptance(207);
    last_acceptance_input_position = QUEX_NAME(Buffer_tell_memory_adr)(&me->buffer);
    
    QUEX_DEBUG_PRINT(&engine->buffer, "FORWARD_BUFFER_RELOAD");
    if( QUEX_NAME(buffer_reload_forward)(&me->buffer, &last_acceptance_input_position,
                                                      post_context_start_position, PostContextStartPositionN) ) {
       goto STATE_686_INPUT;
    }

    QUEX_DEBUG_PRINT(&me->buffer, "BUFFER_RELOAD_FAILED");
    QUEX_GOTO_last_acceptance();




  /* (*) Terminal states _______________________________________________________*/
  /**/
  /* Acceptance terminal states, i.e. the 'winner patterns'. This means*/
  /* that the last input dropped out of a state where the longest matching*/
  /* pattern was according to the terminal state. The terminal states are */
  /* numbered after the pattern id.*/
  /**/

/* Lexeme descriptions: There is a temporary zero stored at the end of each
 * lexeme. A pointer to the zero provides the Null-lexeme.                     */
#define Lexeme       (me->buffer._lexeme_start_p)
#define LexemeBegin  (me->buffer._lexeme_start_p)
#define LexemeEnd    (me->buffer._input_p)
#define LexemeNull   (&__QuexLexemeNullObject)
#define LexemeL      (me->buffer._input_p - me->buffer._lexeme_start_p)
TERMINAL_197:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_197");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_197_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_197_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 331 "depythonize_c.qx"
        
            self.send(QUEX_TKN_BACKSLASH,Lexeme);
            self.allow_opening_indentation_f = false;
            RETURN;
          
        
#line 2945 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_199:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_199");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_199_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_199_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 337 "depythonize_c.qx"
        self_send1(QUEX_TKN_PREPROCESSOR_MULTILINE_CONTINUE, Lexeme);
        CONTINUE;
        
#line 2972 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_201:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_201");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_201_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_201_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 339 "depythonize_c.qx"
        self_send1(QUEX_TKN_SEMICOLON, Lexeme);
        CONTINUE;
        
#line 2999 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_203:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_203");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_203_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_203_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 2);
        #   endif
        
        #line 341 "depythonize_c.qx"
        
            self << ML_COMMENT_READER;
            self.accumulator.add(Lexeme,LexemeEnd);
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 3030 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_205:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_205");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_205_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_205_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 348 "depythonize_c.qx"
        
            self << STRING_READER;
            self.accumulator.add(Lexeme,LexemeEnd);
            self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            return;
          
        
#line 3061 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_207:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_207");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_207_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_207_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 355 "depythonize_c.qx"
        self_send1(QUEX_TKN_COMMENT, Lexeme);
        CONTINUE;
        
#line 3087 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_209:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_209");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_209_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_209_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 357 "depythonize_c.qx"
        
            if(self.parentheses_counter == 0)
              self.send(QUEX_TKN_START_PARENTHESIS_BLOCK,Lexeme);
            else
              self.send(QUEX_TKN_CODE,Lexeme);
            self.parentheses_counter += 1;
            RETURN;
          
        
#line 3120 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_211:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_211");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_211_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_211_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, 1);
        #   endif
        
        #line 365 "depythonize_c.qx"
        
            self.parentheses_counter -= 1;
            if(self.parentheses_counter == 0)
              self.send(QUEX_TKN_END_PARENTHESIS_BLOCK,Lexeme);
            else
              self.send(QUEX_TKN_CODE,Lexeme);
            RETURN;
          
        
#line 3153 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_213:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_213");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_213_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_213_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 374 "depythonize_c.qx"
        self_send1(QUEX_TKN_WORD, Lexeme);
        CONTINUE;
        
#line 3179 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_215:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_215");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

/*RMINAL_215_DIRECT*/    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_215_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount_NoNewline_NeverStartOnWhitespace)(&self.counter, LexemeL);
        #   endif
        
        #line 376 "depythonize_c.qx"
        self_send1(QUEX_TKN_NUMBER, Lexeme);
        CONTINUE;
        
#line 3205 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;

TERMINAL_217:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_217");

    QUEX_NAME(Buffer_seek_memory_adr)(&me->buffer, last_acceptance_input_position);

TERMINAL_217_DIRECT:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_217_DIRECT");

    QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
    {
        {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 386 "depythonize_c.qx"
        
            if( *Lexeme == '\n'){
              self.send(QUEX_TKN_NEWLINE);
              self.send(QUEX_TKN_PREPROCESSOR_MULTILINE_END,Lexeme);
              /*........................................*/
              self << PROGRAM;
              self.send(QUEX_TKN_EVENT_MODE_CHANGE);
            }
            else
              self.send(QUEX_TKN_WHITESPACE,Lexeme);
          
        
#line 3241 "depythonize_c_lex.cpp"
        
        }
    }

    goto __REENTRY_PREPARATION;



TERMINAL_END_OF_STREAM:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_END_OF_STREAM");

                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
            QUEX_NAME(CounterLineColumnIndentation_on_end_of_file)(&self.counter);
        #   endif
        
        #line 92 "depythonize_c.qx"
        self_send0(QUEX_TKN_TERMINATION);
        
#line 3263 "depythonize_c_lex.cpp"
        
        }
                }

     /* End of Stream causes a return from the lexical analyzer, so that no
      * tokens can be filled after the termination token.                    */
     return;          

TERMINAL_FAILURE:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: TERMINAL_FAILURE");

me->buffer._input_p = me->buffer._lexeme_start_p;
if( QUEX_NAME(Buffer_is_end_of_file)(&me->buffer) ) {

    /* Next increment will stop on EOF character. */
}

else {
    /* Step over nomatching character */
    QUEX_NAME(Buffer_input_p_increment)(&me->buffer);
}

                QUEX_NAME(Buffer_set_terminating_zero_for_lexeme)(&me->buffer);
                {
                    {
        #   ifdef __QUEX_OPTION_COUNTER
        CounterBase_shift_end_values_to_start_values(&self.counter.base);
        QUEX_NAME(CounterLineColumnIndentation_icount)(&self.counter, Lexeme, LexemeEnd);
        #   endif
        
        #line 398 "depythonize_c.qx"
        
            self.send(QUEX_TKN_CODE,Lexeme);
          
        
#line 3299 "depythonize_c_lex.cpp"
        
        }
                }

     goto __REENTRY_PREPARATION;

#undef Lexeme
#undef LexemeBegin
#undef LexemeEnd
#undef LexemeNull
#undef LexemeL
#ifndef __QUEX_OPTION_USE_COMPUTED_GOTOS
__TERMINAL_ROUTER: {
        /*  if last_acceptance => goto correspondent acceptance terminal state*/
        /*  else               => execute defaul action*/
        switch( last_acceptance ) {
            case 197: goto TERMINAL_197;
            case 199: goto TERMINAL_199;
            case 201: goto TERMINAL_201;
            case 203: goto TERMINAL_203;
            case 205: goto TERMINAL_205;
            case 207: goto TERMINAL_207;
            case 209: goto TERMINAL_209;
            case 211: goto TERMINAL_211;
            case 213: goto TERMINAL_213;
            case 215: goto TERMINAL_215;
            case 217: goto TERMINAL_217;

            default: goto TERMINAL_FAILURE;; /* nothing matched */
        }
    }
#endif /* __QUEX_OPTION_USE_COMPUTED_GOTOS */

  
__REENTRY_PREPARATION:
    QUEX_DEBUG_PRINT(&me->buffer, "LABEL: __REENTRY_PREPARATION");

    /* (*) Common point for **restarting** lexical analysis.
     *     at each time when CONTINUE is called at the end of a pattern. */
    
#ifndef   __QUEX_OPTION_PLAIN_ANALYZER_OBJECT
#   ifdef __QUEX_OPTION_TOKEN_POLICY_IS_QUEUE_BASED
    if( QUEX_NAME(TokenQueue_is_full)(&self._token_queue) ) return;
#   else
    if( self.token->type_id() != __QUEX_SETTING_TOKEN_ID_UNINITIALIZED) return;
#   endif
#endif

    last_acceptance = QUEX_GOTO_TERMINAL_LABEL_INIT_VALUE;


    /* Post context positions do not have to be reset or initialized. If a state
     * is reached which is associated with 'end of post context' it is clear what
     * post context is meant. This results from the ways the state machine is 
     * constructed. A post context positions live time looks like the following:
     *
     * (1)   unitialized (don't care)
     * (1.b) on buffer reload it may, or may not be adapted (don't care)
     * (2)   when a post context begin state is passed, the it is **SET** (now: take care)
     * (2.b) on buffer reload it **is adapted**.
     * (3)   when a terminal state of the post context is reached (which can only be reached
     *       for that particular post context, then the post context position is used
     *       to reset the input position.                                              */

    /*  If a mode change happened, then the function must first return and
     *  indicate that another mode function is to be called. At this point, 
     *  we to force a 'return' on a mode change. 
     *
     *  Pseudo Code: if( previous_mode != current_mode ) {
     *                   return 0;
     *               }
     *
     *  When the analyzer returns, the caller function has to watch if a mode change
     *  occured. If not it can call this function again.                               */
#if    defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)     || defined(QUEX_OPTION_ASSERTS)
    if( me->DEBUG_analyzer_function_at_entry != me->current_analyzer_function ) 
#endif
    { 
#if defined(QUEX_OPTION_AUTOMATIC_ANALYSIS_CONTINUATION_ON_MODE_CHANGE)
    QUEX_TOKEN_POLICY_SET_ID(__QUEX_SETTING_TOKEN_ID_UNINITIALIZED);
    return;
#elif defined(QUEX_OPTION_ASSERTS)
    QUEX_ERROR_EXIT("Mode change without immediate return from the lexical analyzer.");
#endif
    }

    goto __REENTRY;

    /* prevent compiler warning 'unused variable': use variables once in a part of the code*/
    /* that is never reached (and deleted by the compiler anyway).*/
    if( 0 == 1 ) {
        int unused = 0;
        unused += (int)ML_COMMENT_READER.id;
        unused += (int)STRING_READER.id;
        unused += (int)PROGRAM.id;
        unused += (int)ML_PREPROCESOR_READER.id;
        unused += (int)__QuexLexemeNullObject;
    }
#   undef ML_COMMENT_READER
#   undef STRING_READER
#   undef PROGRAM
#   undef ML_PREPROCESOR_READER
}
#include <quex/code_base/temporary_macros_off>
QUEX_NAMESPACE_MAIN_CLOSE